export class Recorder {
    constructor() {
        this.mediaStream = null;
        this.mediaRecorder = null;
        this.recordedChunks = [];
        this.isRecording = false;
        this.isPaused = false;
    }

    /**
     * 设置要录制的媒体流
     * @param {MediaStream} stream - 要录制的媒体流
     */
    setStream(stream) {
        // 停止现有流（如果有）
        if (this.mediaStream) {
            this.mediaStream.getTracks().forEach(track => track.stop());
        }

        this.mediaStream = stream;
    }

    /**
     * 开始录制
     * @returns {boolean} - 录制是否成功开始
     */
    start() {
        if (!this.mediaStream) {
            console.error('没有可用的媒体流，请先设置媒体流');
            return false;
        }

        if (this.isRecording) {
            console.warn('已经在录制中');
            return false;
        }

        try {
            // 创建录制用的流副本，以便可以修改原始流
            const recordingStream = new MediaStream(this.mediaStream.getTracks());

            // 初始化录制器
            this.mediaRecorder = new MediaRecorder(recordingStream);
            this.recordedChunks = [];

            // 存储录制数据
            this.mediaRecorder.ondataavailable = (e) => {
                if (e.data.size > 0) {
                    this.recordedChunks.push(e.data);
                }
            };

            // 开始录制
            this.mediaRecorder.start();
            this.isRecording = true;
            this.isPaused = false;
            return true;
        } catch (error) {
            console.error('录制开始失败:', error);
            return false;
        }
    }

    /**
     * 暂停或继续录制
     * @returns {boolean} - 操作是否成功
     */
    togglePause() {
        if (!this.mediaRecorder || !this.isRecording) {
            console.error('没有正在进行的录制');
            return false;
        }

        try {
            if (this.isPaused) {
                this.mediaRecorder.resume();
            } else {
                this.mediaRecorder.pause();
            }
            this.isPaused = !this.isPaused;
            return true;
        } catch (error) {
            console.error('暂停/继续录制失败:', error);
            return false;
        }
    }

    /**
     * 停止录制并自动下载
     * @param {string} [fileName] - 可选的文件名
     * @returns {Promise<Blob>} - 录制的视频Blob对象
     */
    stop(fileName) {
        return new Promise((resolve, reject) => {
            if (!this.mediaRecorder || !this.isRecording) {
                reject(new Error('没有正在进行的录制'));
                return;
            }

            try {
                this.mediaRecorder.onstop = () => {
                    const blob = new Blob(this.recordedChunks, { type: 'video/mp4' });
                    this.isRecording = false;
                    this.isPaused = false;

                    // 创建下载链接
                    this._createDownloadLink(blob, fileName);
                    resolve(blob);
                };

                this.mediaRecorder.stop();
            } catch (error) {
                console.error('停止录制失败:', error);
                reject(error);
            }
        });
    }

    /**
     * 替换录制中的媒体流（自动处理所有轨道）
     * @param {MediaStream} newStream - 新的媒体流
     * @returns {boolean} - 替换是否成功
     */
    replaceStream(newStream) {
        if (!this.mediaStream || !this.isRecording) {
            console.error('没有活跃的媒体流或不在录制状态');
            return false;
        }

        try {
            // 获取新流中的所有轨道
            const newTracks = newStream.getTracks();

            // 为每种类型的轨道（视频/音频）进行替换
            newTracks.forEach(newTrack => {
                const kind = newTrack.kind;

                // 替换录制流中的轨道
                const oldRecorderTrack = this.mediaRecorder.stream.getTracks()
                    .find(track => track.kind === kind);

                if (oldRecorderTrack) {
                    this.mediaRecorder.stream.removeTrack(oldRecorderTrack);
                }
                this.mediaRecorder.stream.addTrack(newTrack);

                // 替换预览流中的轨道
                const oldPreviewTrack = this.mediaStream.getTracks()
                    .find(track => track.kind === kind);

                if (oldPreviewTrack) {
                    this.mediaStream.removeTrack(oldPreviewTrack);
                }
                this.mediaStream.addTrack(newTrack);
            });

            return true;
        } catch (error) {
            console.error('替换媒体流失败:', error);
            return false;
        }
    }

    /**
     * 获取当前录制状态
     * @returns {Object} - 包含录制状态的对象
     */
    getStatus() {
        return {
            isRecording: this.isRecording,
            isPaused: this.isPaused,
            hasStream: !!this.mediaStream
        };
    }

    /**
     * 创建下载链接并触发下载
     * @param {Blob} blob - 要下载的视频Blob
     * @param {string} [fileName] - 可选的文件名
     */
    _createDownloadLink(blob, fileName) {
        // 生成默认文件名（使用时间戳）
        const defaultName = `recording-${new Date().toISOString().replace(/[:.]/g, '-')}.webm`;
        const downloadName = fileName || defaultName;

        // 创建下载链接
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = downloadName;

        // 触发下载
        document.body.appendChild(a);
        a.click();

        // 清理
        setTimeout(() => {
            document.body.removeChild(a);
            URL.revokeObjectURL(url);
        }, 1000);
    }
}

// 导出模块
if (typeof module !== 'undefined' && module.exports) {
    module.exports = Recorder;
}
